home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / nan_news / toolkit / putkey.asm < prev    next >
Assembly Source File  |  1991-08-15  |  11KB  |  233 lines

  1. ; File......: PUTKEY.ASM
  2. ; Author....: Ted Means
  3. ; Date......: $Date:   15 Aug 1991 23:07:10  $
  4. ; Revision..: $Revision:   1.2  $
  5. ; Log file..: $Logfile:   E:/nanfor/src/putkey.asv  $
  6. ; This is an original work by Ted Means and is placed in the
  7. ; public domain.
  8. ;
  9. ; Modification history:
  10. ; ---------------------
  11. ;
  12. ; $Log:   E:/nanfor/src/putkey.asv  $
  13. ;  
  14. ;     Rev 1.2   15 Aug 1991 23:07:10   GLENN
  15. ;  Forest Belt proofread/edited/cleaned up doc
  16. ;  
  17. ;     Rev 1.1   14 Jun 1991 19:54:56   GLENN
  18. ;  Minor edit to file header
  19. ;  
  20. ;     Rev 1.0   01 Apr 1991 01:03:48   GLENN
  21. ;  Nanforum Toolkit
  22. ;  
  23.  
  24. ; $DOC$
  25. ; $FUNCNAME$
  26. ;     FT_PUTKEY()
  27. ; $CATEGORY$
  28. ;     Keyboard/Mouse
  29. ; $ONELINER$
  30. ;     Stuff a keystroke into the keyboard buffer
  31. ; $SYNTAX$
  32. ;     FT_PUTKEY( <nKeyValue> ) -> lResult
  33. ; $ARGUMENTS$
  34. ;     <nKeyValue> is the INKEY() value of the keystroke to be stuffed.
  35. ; $RETURNS$
  36. ;    .T. if the keystroke was put into the keyboard buffer.
  37. ;    .F. if nKeyValue was invalid or the buffer was full.
  38. ; $DESCRIPTION$
  39. ;    This function is similar to the KEYBOARD command, with a few
  40. ;    exceptions. First, this function does not clear the keyboard buffer
  41. ;    before inserting the keystroke.  In addition, since it uses the
  42. ;    Inkey() value, you can stuff any key, including function keys, into
  43. ;    the keyboard buffer. However, this also means that unlike the KEYBOARD
  44. ;    command, you can only stuff one keystroke at a time.
  45. ;
  46. ;    You can easily create a User-Defined Command that makes this function
  47. ;    even more like the KEYBOARD command.  For example,
  48. ;
  49. ;        #command KEYSTROKE <key> => FT_PUTKEY( <key> )
  50. ;
  51. ;    will create a command called KEYSTROKE that could be used as a
  52. ;    companion command to KEYBOARD.  The only difference is that it would
  53. ;    insert a single keystroke instead of a string.
  54. ;
  55. ;    Be aware that early releases of Clipper 5.0 have a bug in their
  56. ;    keyboard handling.  Among other things, Set Typeahead does not work
  57. ;    correctly, so this function may at times return .T. even though the
  58. ;    keyboard buffer is full.  The best solution is not to attempt stuffing
  59. ;    more than 15 keys at a time into the keyboard buffer.
  60. ;
  61. ;    This function is written to adhere to Turbo Assembler's IDEAL mode.
  62. ;    To use another assembler, rearrange the SEGMENT and PROC directives
  63. ;    and make any other necessary changes to the source code.
  64. ; $EXAMPLES$
  65. ;      FT_PUTKEY( -9 )   //  Stuff the F10 key
  66. ;      FT_PUTKEY( 276 )  //  Stuff the Alt T key
  67. ;      KEYSTROKE 28      //  Stuff the F1 key using a User-Defined Command
  68. ; $END$
  69.  
  70.  
  71.          IDEAL
  72.  
  73. Public   FT_PUTKEY
  74.  
  75. EXTRN    __PARINFO:FAR
  76. EXTRN    __PARNI:FAR
  77. EXTRN    __RETL:FAR
  78.  
  79. SEGMENT  _NANFOR   WORD      PUBLIC    "CODE"
  80.          ASSUME    CS:_NANFOR
  81.  
  82. PROC     FT_PUTKEY  FAR
  83.  
  84.          XOR       AX,AX                     ; PREPARE TO COUNT PARAMS
  85.          PUSH      AX                        ; SAVE ON STACK
  86.          CALL      __PARINFO                 ; GET PARAM COUNT
  87.          ADD       SP,2                      ; REALIGN STACK
  88.          OR        AX,AX                     ; ZERO PARAMS?
  89.          JNZ       TEST1                     ; IF NOT, CONTINUE
  90.          JMP       DONE                      ; RETURN VALUE = FALSE, GO TO END
  91.  
  92. TEST1:   MOV       AX,1                      ; PREPARE TO CHECK PARAMETER #1
  93.          PUSH      AX                        ; SAVE PARAMETER # ON STACK
  94.          CALL      __PARINFO                 ; CALL PARAMETER INFO ROUTINE
  95.          ADD       SP,2                      ; REALIGN STACK
  96.          TEST      AX,2                      ; IS PARAMETER NUMERIC?
  97.          JNZ       GET1                      ; IF SO, CONTINUE
  98. BADPARAM:XOR       AX,AX                     ; SET RETURN VALUE TO FALSE
  99.          JMP       DONE                      ; GO TO END
  100.  
  101. GET1:    MOV       AX,1                      ; PREPARE TO RETRIEVE PARAMETER #1
  102.          PUSH      AX                        ; SAVE PARAMETER # ON STACK
  103.          CALL      __PARNI                   ; RETRIEVE PARAMETER
  104.          ADD       SP,2                      ; REALIGN STACK
  105.  
  106.          CMP       AX,385                    ; TEST HIGHEST INKEY()
  107.          JG        BadParam                  ; Bad INKEY() value
  108.          Cmp       AX,-39                    ; Test lowest INKEY()
  109.          JL        BadParam                  ; Process error
  110.  
  111. CtrlF1:  Mov       CL,0                      ; Set ASCII value to null
  112.          Cmp       AX,-10                    ; Is Ctrl F1 thru Alt F10?
  113.          JG        F2                        ; If not, check next range
  114.          Neg       AX                        ; Get absolute value of AX
  115.          Add       AL,74                     ; Translate INKEY() to scan code
  116.          Mov       CH,AL                     ; Move scan code to CH
  117.          JMP       StuffIt                   ; Stuff the keystroke
  118.  
  119. F2:      Or        AX,AX                     ; See if key is F2 thru F10
  120.          JNS       F1                        ; If not, check next range
  121.          Neg       AX                        ; Get absolute value of AX
  122.          Add       AL,59                     ; Translate INKEY() to scan code
  123.          Mov       CH,AL                     ; Move scan code to CH
  124.          JMP       StuffIt                   ; Stuff the keystroke
  125.  
  126. F1:      Cmp       AX,28                     ; See if key is F1
  127.          JNE       CtrlF                     ; If not, check next key
  128.          Mov       CH,59                     ; Supply scan code for F1
  129.          JMP       StuffIt                   ; Stuff the keystroke
  130.  
  131. CtrlF:   Cmp       AX,6                      ; See if key is Ctrl F or End
  132.          JNE       CtrlW                     ; If not, check next key
  133.          Mov       CH,79                     ; Supply scan code for End
  134.          JMP       StuffIt                   ; Stuff the keystroke
  135.  
  136. CtrlW:   Cmp       AX,23                     ; See if key is Ctrl W or Ctrl End
  137.          JNE       CtrlHome                  ; If not, check next key
  138.          Mov       CH,117                    ; Supply scan code for Ctrl End
  139.          JMP       Short StuffIt             ; Stuff the keystroke
  140.  
  141. CtrlHome:Cmp       AX,29                     ; See if key is Ctrl Home or Ctrl]
  142.          JNE       CtrlV                     ; If not, check next key
  143.          Mov       CH,119                    ; Supply scan code for Ctrl Home
  144.          JMP       Short StuffIt             ; Stuff the keystroke
  145.  
  146. CtrlV:   Cmp       AX,22                     ; See if key is Ins or Ctrl V
  147.          JNE       ShiftTab                  ; If not, check next key
  148.          Mov       CH,82                     ; Supply scan code for Ctrl V
  149.          JMP       Short StuffIt             ; Stuff the keystroke
  150.  
  151. ShiftTab:Cmp       AX,271                    ; See if key is Shift Tab
  152.          JNE       CtrlPgDn                  ; If not, check next key
  153.          Mov       CH,15                     ; Supply scan code for Shift Tab
  154.          JMP       Short StuffIt             ; Stuff the keystroke
  155.  
  156. CtrlPgDn:Cmp       AX,30                     ; See if key is Ctrl PgDn
  157.          JNE       CtrlPgUp                  ; If not, check next key
  158.          Mov       CH,118                    ; Supply scan code for Ctrl PgDn
  159.          JMP       Short StuffIt             ; Stuff the keystroke
  160.  
  161. CtrlPgUp:Cmp       AX,31                     ; See if key is Ctrl PgUp
  162.          JNE       AltQ                      ; If not, check next key
  163.          Mov       CH,132                    ; Supply scan code for Ctrl PgUp
  164.          JMP       Short StuffIt             ; Stuff the keystroke
  165.  
  166. AltQ:    Cmp       AX,272                    ; See if key is Alt Q . . .
  167.          JL        ASCII
  168.          Cmp       AX,281                    ; . . . thru Alt P
  169.          JG        AltA
  170.          Mov       CH,AL
  171.          JMP       Short StuffIt
  172.  
  173. AltA:    Cmp       AX,286                    ; See if key is Alt A . . .
  174.          JNL       AltL
  175.          JMP       BadParam
  176. AltL:    Cmp       AX,294                    ; . . . thru Alt L
  177.          JG        AltZ
  178.          Mov       CH,AL
  179.          JMP       Short StuffIt
  180.  
  181. AltZ:    Cmp       AX,300                    ; See if key is Alt Z . . .
  182.          JNL       AltM
  183.          JMP       BadParam
  184. AltM:    Cmp       AX,306                    ; . . . thru Alt M
  185.          JG        Alt1
  186.          Mov       CH,AL
  187.          Mov       CL,0
  188.          JMP       Short StuffIt
  189.  
  190. Alt1:    Cmp       AX,376                    ; See if key is Alt 1 . . .
  191.          JNL       AltNum
  192.          JMP       BadParam
  193. AltNum:  Mov       CH,AL
  194.          Mov       CL,0
  195.          JMP       Short StuffIt
  196.  
  197. ASCII:   Or        AH,AH                     ; See if key is plain ASCII
  198.          JZ        Okay
  199.          JMP       BadParam
  200. Okay:    Mov       CX,AX
  201.  
  202. StuffIt: CLI                                 ; Disable keyboard temporarily
  203.          Push      DS                        ; Save DS
  204.          Xor       AX,AX                     ; Clear AX
  205.          Mov       DS,AX                     ; Point DS to low RAM
  206.          Mov       AX,[Word Ptr 41Ch]        ; Get tail pointer
  207.          Add       AX,2                      ; Make room for keystroke
  208.          Cmp       AX,3Eh                    ; Need to wrap?
  209.          JNE       IsItFull                  ; No, so continue
  210.          Mov       AX,1Eh                    ; Wrap tail
  211. IsItFull:Cmp       AX,[Word Ptr 41Ah]        ; Is buffer full?
  212.          JNE       PutChar                   ; No, so continue
  213.          Xor       AX,AX                     ; Set return value to .F.
  214.          Jmp       Short Exit                ; Quit
  215.  
  216. PutChar: Mov       BX,[Word Ptr 41Ch]        ; Get tail pointer
  217.          Add       BX,400h                   ; Adjust offset by constant
  218.          Mov       [Word Ptr BX],CX          ; Stuff keystroke
  219.          Mov       [Word Ptr 41Ch],AX        ; Save new buffer tail
  220.          Mov       AX,1                      ; Set return value to .T.
  221.  
  222. Exit:    STI                                 ; Enable keystrokes again
  223.          Pop       DS                        ; Restore DS
  224.  
  225. Done:    Push      AX                        ; Save return value on stack
  226.          Call      __RetL                    ; Return it to Clipper app
  227.          Add       SP,2                      ; Realign stack
  228.          Ret
  229. Endp     FT_PutKey
  230. Ends     _NanFor
  231. End
  232.